package org.csu.softwaremetrics_demo.entity.common;

import java.util.HashMap;
import java.util.Map;
import java.util.StringJoiner;

/**
 * @Description: CKMetricSingleClass类用于存储单个类的CK度量指标。
 * @Author: Jukomu
 * @Package: org.csu.softwaremetrics_demo.entity.common
 * @Project: SoftwareMetrics_demo
 * @name: CKMetricSingleClass
 * @Date: 2025/4/6-20:14
 * @Filename: CKMetricSingleClass
 */

public class CKMetricSingleClass {
    // 文件路径
    private String file;
    // 类名
    private String className;
    // 类类型
    private String type;

    // 类的继承深度
    private int dit;
    // 子类数量
    private int noc;
    // 类的加权方法数量
    private int wmc;
    // 类的耦合度
    private int cbo;
    // 类的 Lack of Cohesion in Methods
    private int lcom;
    // 类的响应方法数量
    private int rfc;
    // 类的方法数量
    private int nom;
    // 类的公共方法数量
    private int nopm;
    // 类的静态方法数量
    private int nosm;

    // 类的字段数量
    private int nof;
    // 类的公共字段数量
    private int nopf;
    // 类的静态字段数量
    private int nosf;

    // 类的接口数量
    private int nosi;
    // 类的代码行数
    private int loc;

    // 特定度量指标的映射
    private final Map<String, Integer> specific;
    // 是否存在错误
    private boolean error;

    // 构造函数，初始化文件路径、类名和类类型
    public CKMetricSingleClass(String file, String className, String type) {
        this.file = file;
        this.className = className;
        this.type = type;

        this.specific = new HashMap<>();
    }

    // 将CK度量指标转换为Map
    public Map<String, Object> toMap() {
        Map<String, Object> map = new HashMap<>();
        String[] pathList = file.split("\\\\");
        map.put("file", pathList[pathList.length - 1]);
        map.put("class", className);
        map.put("type", type);
        map.put("wmc", wmc);
        map.put("rfc", rfc);
        map.put("lcom", lcom);
        map.put("cbo", cbo);
        map.put("dit", dit);
        map.put("noc", noc);
        map.put("nom", nom);
        map.put("nopm", nopm);
        map.put("nosm", nosm);
        map.put("nof", nof);
        map.put("nopf", nopf);
        map.put("nosf", nosf);
        map.put("nosi", nosi);
        map.put("loc", loc);
        return map;
    }

    // 重写hashCode方法，基于文件路径计算哈希值
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((file == null) ? 0 : file.hashCode());
        return result;
    }

    // 重写equals方法，基于文件路径判断两个对象是否相等
    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        CKMetricSingleClass other = (CKMetricSingleClass) obj;
        if (file == null) {
            return other.file == null;
        } else {
            return file.equals(other.file);
        }
    }

    // 获取类的继承深度
    public int getDit() {
        return dit;
    }

    // 设置类的继承深度
    public void setDit(int dit) {
        this.dit = dit;
    }

    // 设置文件路径
    public void setFile(String file) {
        this.file = file;
    }

    // 获取类名
    public String getClassName() {
        return className;
    }

    // 增加子类数量
    public void incNoc() {
        incNoc(1);
    }

    // 获取子类数量
    public int getNoc() {
        return noc;
    }

    // 设置类的加权方法数量
    public void setWmc(int cc) {
        this.wmc = cc;
    }

    // 获取类的加权方法数量
    public int getWmc() {
        return wmc;
    }

    // 获取类的耦合度
    public int getCbo() {
        return cbo;
    }

    // 设置类的耦合度
    public void setCbo(int cbo) {
        this.cbo = cbo;
    }

    // 设置类的 Lack of Cohesion in Methods
    public void setLcom(int lcom) {
        this.lcom = lcom;
    }

    // 获取类的 Lack of Cohesion in Methods
    public int getLcom() {
        return lcom;
    }

    // 设置类的响应方法数量
    public void setRfc(int rfc) {
        this.rfc = rfc;
    }

    // 获取类的响应方法数量
    public int getRfc() {
        return rfc;
    }

    // 设置类的方法数量
    public void setNom(int nom) {
        this.nom = nom;
    }

    // 获取类的方法数量
    public int getNom() {
        return nom;
    }

    // 获取特定度量指标的值
    public int getSpecific(String key) {
        if (!specific.containsKey(key)) return -1;
        return specific.get(key);
    }

    // 添加特定度量指标
    public void addSpecific(String key, int value) {
        specific.put(key, value);
    }

    // 获取类类型
    public String getType() {
        return type;
    }

    // 获取类的公共方法数量
    public int getNopm() {
        return nopm;
    }

    // 设置类的公共方法数量
    public void setNopm(int nopm) {
        this.nopm = nopm;
    }

    // 获取类的静态方法数量
    public int getNosm() {
        return nosm;
    }

    // 设置类的静态方法数量
    public void setNosm(int nosm) {
        this.nosm = nosm;
    }

    // 获取类的字段数量
    public int getNof() {
        return nof;
    }

    // 设置类的字段数量
    public void setNof(int nof) {
        this.nof = nof;
    }

    // 获取类的公共字段数量
    public int getNopf() {
        return nopf;
    }

    // 设置类的公共字段数量
    public void setNopf(int nopf) {
        this.nopf = nopf;
    }

    // 获取类的静态字段数量
    public int getNosf() {
        return nosf;
    }

    // 设置类的静态字段数量
    public void setNosf(int nosf) {
        this.nosf = nosf;
    }

    // 获取类的接口数量
    public int getNosi() {
        return nosi;
    }

    // 设置类的接口数量
    public void setNosi(int nosi) {
        this.nosi = nosi;
    }

    // 获取类的代码行数
    public int getLoc() {
        return loc;
    }

    // 设置类的代码行数
    public void setLoc(int loc) {
        this.loc = loc;
    }

    // 判断是否存在错误
    public boolean isError() {
        return error;
    }

    // 设置错误标志
    public void error() {
        this.error = true;
    }

    // 重写toString方法，返回类的字符串表示
    @Override
    public String toString() {
        return new StringJoiner(", ", CKMetricSingleClass.class.getSimpleName() + "[", "]")
                .add("file='" + file + "'")
                .add("className='" + className + "'")
                .add("type='" + type + "'")
                .add("dit=" + dit)
                .add("noc=" + noc)
                .add("wmc=" + wmc)
                .add("cbo=" + cbo)
                .add("lcom=" + lcom)
                .add("rfc=" + rfc)
                .add("nom=" + nom)
                .add("nopm=" + nopm)
                .add("nosm=" + nosm)
                .add("nof=" + nof)
                .add("nopf=" + nopf)
                .add("nosf=" + nosf)
                .add("nosi=" + nosi)
                .add("loc=" + loc)
                .add("specific=" + specific)
                .add("error=" + error)
                .toString();
    }

    // 增加子类数量
    public void incNoc(int value) {
        this.noc += value;
    }

    // 获取文件路径
    public String getFile() {
        return file;
    }

    // 设置类名
    public void setClassName(String className) {
        this.className = className;
    }

    // 设置类类型
    public void setType(String type) {
        this.type = type;
    }

    // 设置子类数量
    public void setNoc(int noc) {
        this.noc = noc;
    }

    // 设置错误标志
    public void setError(boolean error) {
        this.error = error;
    }

    // 获取特定度量指标的映射
    public Map<String, Integer> getSpecific() {
        return specific;
    }
}
